#ifndef V2_NIM_DEF_STRUCT_H
#define V2_NIM_DEF_STRUCT_H
#include "v2_nim_def_enum.hpp"

namespace v2 {

struct V2NIMError {
    /// 错误码, 详见 V2NIMErrorCode
    uint32_t code{V2NIM_ERROR_CODE_UNKNOWN};
    /// 错误描述
    nstd::string desc;
    /// 错误详情
    nstd::map<nstd::string, nstd::string> detail;
    V2NIMError() = default;
    V2NIMError(uint32_t code, std::pair<nstd::string, nstd::string> pair = {});
    nstd::string& operator[](const nstd::string& key);
};

struct V2NIMSize {
    /// 宽
    int32_t width{0};
    /// 高
    int32_t height{0};
};

struct V2NIMLinkOption {
    /// 连接超时, 单位毫秒
    uint64_t linkTimeout{DEFAULT_LINK_TIMEOUT};
    /// 协议超时, 单位毫秒
    uint64_t protocolTimeout{DEFAULT_PROTOCOL_TIMEOUT};
    /// 非对称加密"交换密钥"协议加密算法
    V2NIMAsymmetricEncryptionAlgorithm asymmetricEncryptionAlgorithm{V2NIM_ASYMMETRIC_ENCRYPTION_ALGORITHM_RSA};
    /// 对称加密通信加密算法
    V2NIMSymmetricEncryptionAlgorithm symmetricEncryptionAlgorithm{V2NIM_SYMMETRIC_ENCRYPTION_ALGORITHM_RC4};
};

struct V2NIMFCSOption {
    /// 融合存储认证类型
    V2NIMFCSAuthType fcsAuthType{V2NIM_FCS_AUTH_TYPE_NONE};
    /// 自定义鉴权 Refer 信息
    nstd::string customAuthRefer;
    /// 自定义鉴权 User Agent 信息
    nstd::string customAuthUA;
};

struct V2NIMPrivateServerOption {
    /// IP 协议版本
    V2NIMIPProtocolVersion ipProtocolVersion{V2NIM_IP_PROTOCOL_VERSION_IPV4};
    /// lbs 地址
    nstd::vector<nstd::string> lbsAddresses;
    /// nos lbs 地址
    nstd::string nosLbsAddress;
    /// 默认 link 地址
    nstd::string defaultLinkAddress;
    /// 默认 ipv6 link 地址
    nstd::string defaultLinkAddressIpv6;
    /// 默认 nos 上传地址
    nstd::string defaultNosUploadAddress;
    /// 默认 nos 上传主机地址
    nstd::string defaultNosUploadHost;
    /// nos 下载地址拼接模板, 用于拼接最终得到的下载地址
    nstd::string nosDownloadAddress;
    /// nos 加速域名列表
    nstd::vector<nstd::string> nosAccelerateHosts;
    /// nos 加速地址拼接模板, 用于获得加速后的下载地址
    nstd::string nosAccelerateAddress;
    /// 探测 ipv4 地址类型使用的 url
    nstd::string probeIpv4Url;
    /// 探测 ipv6 地址类型使用的 url
    nstd::string probeIpv6Url;
    /// 非对称加密密钥 A, RSA: module, SM2: X
    nstd::string asymmetricEncryptionKeyA;
    /// 非对称加密密钥 B, RSA: EXP, SM2: SM2Y
    nstd::string asymmetricEncryptionKeyB;
    /// 非对称加密算法 key 版本号
    uint32_t asymmetricEncryptionKeyVersion{0};
};

struct V2NIMDatabaseOption {
    /// 数据库加密密钥
    nstd::string encryptionKey;
    /// 是否开启用户数据备份(本地)功能
    bool enableBackup{true};
    /// 是否开启用户数据恢复(本地)功能
    bool enableRestore{true};
    /// 用户数据备份(本地)目录, 缺省在数据文件所在目录创建一个dbFile.back目录
    nstd::string backupFolder;
    /// SQLCipher 版本, 仅 macOS / Linux 平台有效
    V2NIMSQLCipherVersion sqlcipherVersion{V2NIM_SQLCIPHER_VERSION_4};
};

struct V2NIMBasicOption {
    /// 是否使用 https
    bool useHttps{true};
    /// 是否使用 httpdns
    bool useHttpdns{true};
    /// 自定义客户端类型
    uint32_t customClientType{0};
    /// 登录自定义信息, 最大 32 个字符
    nstd::string customTag;
    /// 日志保留天数
    uint32_t logReserveDays{V2NIM_DEFAULT_LOG_RESERVE_DAYS};
    /// SDK日志级别
    V2NIMSDKLogLevel sdkLogLevel{V2NIM_SDK_LOG_LEVEL_APP};
    /// 是否禁用 macOS 下的 App Nap 功能
    bool disableAppNap{true};
    /// @internal
    uint32_t sdkType{0};
    /// @internal
    nstd::function<void(nstd::string log)> logCallback;
};

struct V2NIMInitOption {
    /// app key
    nstd::string appkey;
    /// app 数据目录, 为空则使用默认目录
    nstd::string appDataPath;
    /// 基础配置
    V2NIMBasicOption basicOption;
    /// 连接相关配置
    V2NIMLinkOption linkOption;
    /// 数据库配置
    V2NIMDatabaseOption databaseOption;
    /// 融合存储配置
    V2NIMFCSOption fcsOption;
    /// 私有化配置
    nstd::optional<V2NIMPrivateServerOption> privateServerOption;
};

struct V2NIMStorageScene {
    /// 场景名
    nstd::string sceneName;
    /// 过期时间, 单位秒, 0 表示不过期
    uint64_t expireTime{0};
};

struct V2NIMChatroomEnterInfo {
    /// 进入聊天室后显示的昵称
    nstd::string roomNick;
    /// 进入聊天室后显示的头像
    nstd::string roomAvatar;
    /// 用户进入聊天室的时间点
    uint64_t enterTime{0};
    /// 进入的终端类型
    uint32_t clientType{0};
};

struct V2NIMChatroomMember {
    /// 聊天室 ID
    nstd::string roomId;
    /// 成员账号 ID
    nstd::string accountId;
    /// 聊天室成员角色
    V2NIMChatroomMemberRole memberRole{V2NIM_CHATROOM_MEMBER_ROLE_NORMAL};
    /// 成员等级, 0 表示未设置
    nstd::optional<uint32_t> memberLevel;
    /// 进入聊天室后显示的昵称
    nstd::optional<nstd::string> roomNick;
    /// 进入聊天室后显示的头像
    nstd::optional<nstd::string> roomAvatar;
    /// 聊天室成员扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 用户是否在线
    bool isOnline{true};
    /// 是否在黑名单中
    bool blocked{false};
    /// 是否禁言
    bool chatBanned{false};
    /// 是否临时禁言
    bool tempChatBanned{false};
    /// 临时禁言时长, 单位秒
    uint64_t tempChatBannedDuration{0};
    /// 登录标签
    nstd::vector<nstd::string> tags;
    /// 登录登出通知标签
    nstd::string notifyTargetTags;
    /// 用户进入聊天室的时间点
    uint64_t enterTime{0};
    /// 更新时间
    uint64_t updateTime{0};
    /// 是否有效
    bool valid{true};
    /// 多端登录信息
    nstd::vector<V2NIMChatroomEnterInfo> multiEnterInfo;
};

struct V2NIMChatroomUpdateParams {
    /// 聊天室名称
    nstd::optional<nstd::string> roomName;
    /// 聊天室公告
    nstd::optional<nstd::string> announcement;
    /// 聊天室直播地址
    nstd::optional<nstd::string> liveUrl;
    /// 聊天室扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 是否需要通知
    bool notificationEnabled{true};
    /// 本次操作生成的通知中的扩展字段
    nstd::string notificationExtension;
    /// @internal
    nstd::optional<V2NIMChatroomQueueLevelMode> queueLevelMode;
};

struct V2NIMUpdateTeamInfoParams {
    /// 新修改群组名称
    nstd::optional<nstd::string> name;
    /// 群组人数上限
    nstd::optional<uint32_t> memberLimit;
    /// 群组介绍
    nstd::optional<nstd::string> intro;
    /// 群组公告
    nstd::optional<nstd::string> announcement;
    /// 群组头像
    nstd::optional<nstd::string> avatar;
    /// 服务端扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 申请入群模式
    nstd::optional<V2NIMTeamJoinMode> joinMode;
    /// 被邀请人入群模式
    nstd::optional<V2NIMTeamAgreeMode> agreeMode;
    /// 群组邀请模式
    nstd::optional<V2NIMTeamInviteMode> inviteMode;
    /// 群组资料修改模式
    nstd::optional<V2NIMTeamUpdateInfoMode> updateInfoMode;
    /// 群组扩展字段修改模式
    nstd::optional<V2NIMTeamUpdateExtensionMode> updateExtensionMode;
};

/// @brief 群组信息更新信息
struct V2NIMUpdatedTeamInfo : V2NIMUpdateTeamInfoParams {
    /// 群禁言状态
    nstd::optional<V2NIMTeamChatBannedMode> chatBannedMode;
};

/// @brief 话单消息通话时长描述信息
struct V2NIMMessageCallDuration {
    /// 话单对应成员的账号 ID
    nstd::string accountId;
    /// 通话时长, 单位秒
    uint32_t duration;
};

// noreflection
struct V2NIMMessageAttachment {
    /// 附件内容
    nstd::string raw;
    /// @internal
    V2NIMMessageAttachmentType attachmentType{V2NIM_MESSAGE_ATTACHMENT_TYPE_UNIVERSAL};
    virtual ~V2NIMMessageAttachment() = default;
};

// noreflection
struct V2NIMMessageFileAttachment : public V2NIMMessageAttachment {
    V2NIMMessageFileAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_FILE; }
    /// 文件大小
    uint64_t size{0};
    /// 文件 md5
    nstd::string md5;
    /// 文件 url
    nstd::string url;
    /// 文件显示名称
    nstd::string name;
    /// 文件本地路径
    nstd::string path;
    /// 文件扩展名
    nstd::string ext;
    /// 文件存储场景
    nstd::string sceneName{V2NIM_STORAGE_SCENE_NAME_DEFAULT_IM};
    /// 附件上传状态
    V2NIMMessageAttachmentUploadState uploadState{V2NIM_MESSAGE_ATTACHMENT_UPLOAD_STATE_UNKNOWN};
};

// noreflection
struct V2NIMMessageImageAttachment : public V2NIMMessageFileAttachment {
    V2NIMMessageImageAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_IMAGE; }
    /// 图片宽度
    uint32_t width{0};
    /// 图片高度
    uint32_t height{0};
};

// noreflection
struct V2NIMMessageAudioAttachment : public V2NIMMessageFileAttachment {
    V2NIMMessageAudioAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_AUDIO; }
    /// 语音文件播放时长
    uint32_t duration{0};
};

// noreflection
struct V2NIMMessageVideoAttachment : public V2NIMMessageFileAttachment {
    V2NIMMessageVideoAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_VIDEO; }
    /// 视频文件播放时长
    uint32_t duration{0};
    /// 图片宽度
    uint32_t width{0};
    /// 图片高度
    uint32_t height{0};
};

// noreflection
struct V2NIMMessageLocationAttachment : public V2NIMMessageAttachment {
    V2NIMMessageLocationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_LOCATION; }
    /// 纬度
    double latitude{0};
    /// 经度
    double longitude{0};
    /// 详细位置信息
    nstd::string address;
};

// noreflection
struct V2NIMMessageCallAttachment : V2NIMMessageAttachment {
    V2NIMMessageCallAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CALL; }
    /// 话单类型， 业务自定义
    int32_t type{0};
    /// 话单频道 ID
    nstd::string channelId;
    /// 通话状态，业务自定义状态
    int32_t status{0};
    /// 通话成员时长列表
    nstd::vector<V2NIMMessageCallDuration> durations;
};

// noreflection
struct V2NIMMessageTeamNotificationAttachment : public V2NIMMessageAttachment {
    V2NIMMessageTeamNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_TEAM_NOTIFICATION; }
    /// 通知类型
    V2NIMMessageNotificationType type{V2NIM_MESSAGE_NOTIFICATION_TYPE_TEAM_INVITE};
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 被操作者 ID 列表
    nstd::vector<nstd::string> targetIds;
    /// 群成员是否被禁言
    bool chatBanned{false};
    /// 群信息更新字段，有相应字段信息，则表示对应字段被修改
    nstd::optional<V2NIMUpdatedTeamInfo> updatedTeamInfo;
};

// noreflection
struct V2NIMChatroomNotificationAttachment : public V2NIMMessageAttachment {
    V2NIMChatroomNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_NOTIFICATION; }
    /// 通知类型
    V2NIMChatroomMessageNotificationType type{V2NIM_CHATROOM_MESSAGE_NOTIFICATION_TYPE_MEMBER_ENTER};
    /// 被操作的成员账号列表
    nstd::vector<nstd::string> targetIds;
    /// 被操作成员的昵称列表
    nstd::vector<nstd::string> targetNicks;
    /// 被操作的标签
    nstd::optional<nstd::string> targetTag;
    /// 操作者
    nstd::string operatorId;
    /// 操作者昵称
    nstd::string operatorNick;
    /// 扩展字段
    nstd::optional<nstd::string> notificationExtension;
    /// 更新后的标签
    nstd::vector<nstd::string> tags;
    /// @internal
    nstd::optional<V2NIMChatroomUpdateParams> chatroomUpdateParams;
    /// @internal
    nstd::optional<V2NIMChatroomMember> chatroomMember;
};

// noreflection
struct V2NIMChatroomMessageRevokeNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomMessageRevokeNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_MESSAGE_REVOKE_NOTIFICATION; }
    /// 消息撤回 ID
    nstd::string messageClientId;
    /// 消息撤回时间
    uint64_t messageTime{0};
};

// noreflection
struct V2NIMChatroomQueueNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomQueueNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_QUEUE_NOTIFICATION; }
    /// 队列变更的内容
    nstd::vector<nstd::map<nstd::string, nstd::string>> keyValues;
    /// 队列更新类型
    V2NIMChatroomQueueChangeType queueChangeType;
};

// noreflection
struct V2NIMChatroomChatBannedNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomChatBannedNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_CHAT_BANNED_NOTIFICATION; }
    /// 成员是否被禁言
    bool chatBanned{false};
    /// 成员是否被临时禁言
    bool tempChatBanned{false};
    /// 成员临时禁言时长
    uint64_t tempChatBannedDuration{0};
};

// noreflection
struct V2NIMChatroomMemberEnterNotificationAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomMemberEnterNotificationAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_MEMBER_ENTER_NOTIFICATION; }
    /// 成员是否被禁言
    bool chatBanned{false};
    /// 成员是否被临时禁言
    bool tempChatBanned{false};
    /// 成员临时禁言时长
    uint64_t tempChatBannedDuration{0};
};

// noreflection
struct V2NIMChatroomMemberRoleUpdateAttachment : public V2NIMChatroomNotificationAttachment {
    V2NIMChatroomMemberRoleUpdateAttachment() { attachmentType = V2NIM_MESSAGE_ATTACHMENT_TYPE_CHATROOM_MEMBER_ROLE_UPDATE_NOTIFICATION; }
    /// 之前的角色类型
    V2NIMChatroomMemberRole previousRole{V2NIM_CHATROOM_MEMBER_ROLE_NORMAL};
    /// 当前的成员信息
    V2NIMChatroomMember currentMember;
};

struct V2NIMMessagePushConfig {
    /// 是否需要推送消息
    bool pushEnabled{true};
    /// 是否需要推送消息发送者昵称
    bool pushNickEnabled{true};
    /// 推送文本
    nstd::string pushContent;
    /// 推送数据
    nstd::string pushPayload;
    /// 是否强制推送, 忽略用户提醒相关设置
    bool forcePush{false};
    /// 强制推送文案
    nstd::string forcePushContent;
    /// 强制推送目标账号列表
    nstd::vector<nstd::string> forcePushAccountIds;
};

struct V2NIMNotificationPushConfig {
    /// 是否需要推送通知
    bool pushEnabled{true};
    /// 是否需要推送消息发送者昵称
    bool pushNickEnabled{true};
    /// 推送文本
    nstd::string pushContent;
    /// 推送数据
    nstd::string pushPayload;
    /// 是否强制推送, 忽略用户提醒相关设置
    bool forcePush{false};
    /// 强制推送文案
    nstd::string forcePushContent;
    /// 强制推送目标账号列表
    nstd::vector<nstd::string> forcePushAccountIds;
};

struct V2NIMMessageAntispamConfig {
    /// 指定是否需要过安全通
    bool antispamEnabled{true};
    /// 指定易盾业务id, 而不使用云信后台配置的
    nstd::optional<nstd::string> antispamBusinessId;
    /// 自定义消息中需要反垃圾的内容(仅当消息类型为自定义消息时有效), json 格式, 长度不超过 5000 字节, 字段如下
    /// type: int, 1: 文本, 2: 图片, 3: 视频
    /// data: string, 文本内容/图片地址/视频地址
    nstd::optional<nstd::string> antispamCustomMessage;
    /// 易盾反作弊(辅助检测数据), json格式, 限制长度 1024 字节
    nstd::optional<nstd::string> antispamCheating;
    /// 易盾反垃圾(增强检测数据), json格式, 限制长度 1024 字节
    nstd::optional<nstd::string> antispamExtension;
};

struct V2NIMNotificationAntispamConfig {
    /// 指定是否需要过安全通
    bool antispamEnabled{true};
    /// 自定义消息中需要反垃圾的内容(仅当消息类型为自定义消息时有效), json 格式, 长度不超过 5000 字节, 字段如下
    /// type: int, 1: 文本, 2: 图片, 3: 视频
    /// data: string, 文本内容/图片地址/视频地址
    nstd::optional<nstd::string> antispamCustomMessage;
};

struct V2NIMMessageRobotConfig {
    /// 机器人账号, 仅群聊有效
    nstd::optional<nstd::string> accountId;
    /// 机器人消息话题
    nstd::optional<nstd::string> topic;
    /// 机器人具体功能, 用户可以自定义输入
    nstd::optional<nstd::string> function;
    /// 机器人自定义内容
    nstd::optional<nstd::string> customContent;
};

struct V2NIMMessageRouteConfig {
    /// 是否需要路由消息
    bool routeEnabled{true};
    /// 路由环境变量, 用于指向不同的抄送, 第三方回调等配置
    nstd::optional<nstd::string> routeEnvironment;
};

struct V2NIMNotificationRouteConfig {
    /// 是否需要路由通知
    bool routeEnabled{true};
    /// 路由环境变量, 用于指向不同的抄送, 第三方回调等配置
    nstd::optional<nstd::string> routeEnvironment;
};

struct V2NIMMessageConfig {
    /// 是否需要消息已读回执信息
    bool readReceiptEnabled{false};
    /// 是否需要更新消息所属的会话信息
    bool lastMessageUpdateEnabled{true};
    /// 是否需要存历史消息
    bool historyEnabled{true};
    /// 是否需要存漫游消息
    bool roamingEnabled{true};
    /// 是否需要发送方多端在线同步消息
    bool onlineSyncEnabled{true};
    /// 是否需要存离线消息
    bool offlineEnabled{true};
    /// 是否需要计未读
    bool unreadEnabled{true};
};

struct V2NIMNotificationConfig {
    /// 是否需要存离线消息
    bool offlineEnabled{true};
    /// 是否需要计未读
    bool unreadEnabled{true};
};

struct V2NIMMessageRefer {
    /// 发送方账号
    nstd::string senderId;
    /// 接收方账号
    nstd::string receiverId;
    /// 客户端消息 id
    nstd::string messageClientId;
    /// 服务端消息 id
    nstd::string messageServerId;
    /// 会话类型
    V2NIMConversationType conversationType{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    /// 会话 ID
    nstd::string conversationId;
    /// 消息时间
    uint64_t createTime{0};
};

struct V2NIMTheadMessageListOption {
    /// 需要查询的消息引用，如果该消息为根消息，则参数为当前消息
    V2NIMMessageRefer messageRefer;
    /// 查询开始时间，小于等于 endTime
    nstd::optional<uint64_t> beginTime;
    /// 查询结束时间
    nstd::optional<uint64_t> endTime;
    /// 锚点消息 ServerId ，该消息必须处于端点，暨消息时间必须等于 beginTime 或 endTime
    nstd::optional<nstd::string> excludeMessageServerId;
    /// 每次查询条数，默认 50
    nstd::optional<uint32_t> limit;
    /// 消息查询方向，如果其它参数都不填
    nstd::optional<V2NIMQueryDirection> direction{V2NIM_QUERY_DIRECTION_DESC};
};

struct V2NIMMessageQueryTime {
    /// 起始时间
    uint64_t begin{0};
    /// 结束时间
    uint64_t end{0};
    /// 包含起始时间
    bool includeBegin{true};
    /// 包含结束时间
    bool includeEnd{false};
};

struct V2NIMMessageStatus {
    /// 消息发送失败后的错误码信息
    V2NIMErrorCode errorCode{V2NIM_ERROR_CODE_UNKNOWN};
    /// 群消息开启已读回执配置，当 V2NIMMessageConfig::readReceiptEnabled 为 true
    /// 时，其他端收到消息后需要发送已读回执请求，该字段记录是否已经发送过已读回执请求，避免重复发送
    bool readReceiptSent{false};
};

/// 调用大模型的请求内容
struct V2NIMAIModelCallContent {
    /// 请求/响应的文本内容
    nstd::string msg;

    /// 类型, 暂时只有 0, 代表文本, 预留扩展能力
    int32_t type;
};

struct V2NIMAIModelCallMessage {
    /// 上下文内容的角色
    V2NIMAIModelRoleType role;
    /// 上下文的内容
    nstd::string msg;
    /// 类型, 暂时只有 0, 代表文本, 预留扩展能力
    int32_t type;
};

struct V2NIMAIModelConfigParams {
    /// 提示词
    nstd::optional<nstd::string> prompt;
    /// 模型最大 tokens 数量
    nstd::optional<int32_t> maxTokens;
    /// 取值范围 (0, 1), 生成时, 核采样方法的概率阈值。
    nstd::optional<double> topP;
    /// 取值范围 (0, 2), 用于控制随机性和多样性的程度。
    nstd::optional<double> temperature;
};

struct V2NIMMessageAIConfig {
    /// 数字人账号信息
    nstd::string accountId;
    /// 缺省表示普通消息
    V2NIMMessageAIStatus aiStatus{V2NIM_MESSAGE_AI_STATUS_UNKNOW};
};

struct V2NIMMessageAIConfigParams {
    /// 数字人账号信息
    nstd::string accountId;
    /// 请求大模型的内容
    nstd::optional<V2NIMAIModelCallContent> content;
    /// 上下文内容
    nstd::optional<nstd::vector<V2NIMAIModelCallMessage>> messages;
    /// 提示词变量占位符替换
    nstd::optional<nstd::string> promptVariables;
    /// 请求接口模型相关参数配置, 如果参数不为空, 则默认覆盖控制相关配置
    nstd::optional<V2NIMAIModelConfigParams> modelConfigParams;
};

struct V2NIMMessage {
    /// 客户端消息 ID
    nstd::string messageClientId;
    /// 服务端消息 ID
    nstd::string messageServerId;
    /// 消息时间
    uint64_t createTime{0};
    /// 消息发送者账号
    nstd::string senderId;
    /// 消息发送者发送该消息时那一刻的昵称
    nstd::string senderName;
    /// 消息接收者账号
    nstd::string receiverId;
    /// 消息所属会话类型
    V2NIMConversationType conversationType{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    /// 消息所属会话 ID
    nstd::string conversationId;
    /// 消息类型
    V2NIMMessageType messageType{V2NIM_MESSAGE_TYPE_TEXT};
    /// 消息内容
    uint32_t subType{0};
    /// 消息文本
    nstd::string text;
    /// 消息附属附件
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    /// 服务端扩展
    nstd::optional<nstd::string> serverExtension;
    /// 本地扩展
    nstd::optional<nstd::string> localExtension;
    /// 回调扩展
    nstd::optional<nstd::string> callbackExtension;
    /// 消息发送状态
    nstd::optional<V2NIMMessageSendingState> sendingState;
    /// 附件上传状态
    nstd::optional<V2NIMMessageAttachmentUploadState> attachmentUploadState;
    /// 消息状态
    V2NIMMessageStatus messageStatus;
    /// 消息相关配置
    V2NIMMessageConfig messageConfig;
    /// 推送相关配置
    V2NIMMessagePushConfig pushConfig;
    /// 路由抄送相关配置
    V2NIMMessageRouteConfig routeConfig;
    /// 反垃圾相关配置
    V2NIMMessageAntispamConfig antispamConfig;
    /// 机器人相关配置
    V2NIMMessageRobotConfig robotConfig;
    /// Thread 消息引用
    nstd::optional<V2NIMMessageRefer> threadRoot;
    /// 回复消息引用
    nstd::optional<V2NIMMessageRefer> threadReply;
    /// AI 数字人相关信息
    nstd::optional<V2NIMMessageAIConfig> aiConfig;
    /// 消息发送者是否是自己
    bool isSelf{false};
    operator V2NIMMessageRefer() const {
        V2NIMMessageRefer messageRefer;
        messageRefer.senderId = senderId;
        messageRefer.receiverId = receiverId;
        messageRefer.messageClientId = messageClientId;
        messageRefer.messageServerId = messageServerId;
        messageRefer.conversationType = conversationType;
        messageRefer.conversationId = conversationId;
        messageRefer.createTime = createTime;
        return messageRefer;
    }
};

struct V2NIMThreadMessageListResult {
    /// 根消息
    V2NIMMessage message;
    /// thread 聊天里最后一条消息的时间戳
    uint64_t timestamp{0};
    /// 获取 thread 聊天里的总回复数
    uint32_t replyCount{0};
    /// 消息回复列表
    nstd::vector<V2NIMMessage> replyList;
};

struct V2NIMCustomNotification {
    /// 通知发送者账号
    nstd::string senderId;
    /// 通知接收者账号
    nstd::string receiverId;
    /// 通知所属会话类型
    V2NIMConversationType conversationType{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    /// 客户设置时间戳
    uint64_t timestamp{0};
    /// 通知内容
    nstd::string content;
    /// 通知相关配置
    V2NIMNotificationConfig notificationConfig;
    /// 离线推送配置相关
    V2NIMNotificationPushConfig pushConfig;
    /// 反垃圾相关配置
    V2NIMNotificationAntispamConfig antispamConfig;
    /// 路由抄送相关配置
    V2NIMNotificationRouteConfig routeConfig;
};

struct V2NIMBroadcastNotification {
    /// 广播通知 ID
    uint64_t id;
    /// 广播通知发送者账号
    nstd::string senderId;
    /// 广播通知时间戳
    uint64_t timestamp;
    /// 广播通知内容
    nstd::string content;
};

struct V2NIMAIModelCallResult {
    /// AI 响应的状态码
    uint32_t code{V2NIM_ERROR_CODE_SUCCESS};
    /// 数字人的账号 ID
    nstd::string accountId;
    /// 本次响应的标识
    nstd::string requestId;
    /// 请求 AI 的回复
    nstd::optional<V2NIMAIModelCallContent> content;
};

struct V2NIMProxyAICallAntispamConfig {
    /// 指定消息是否需要经过安全通。默认为 true
    nstd::optional<bool> antispamEnabled{true};
    /// 指定易盾业务id
    nstd::optional<nstd::string> antispamBusinessId;
};

/// AI 数字人代理请求参数
struct V2NIMProxyAIModelCallParams {
    /// 机器人账号 ID
    nstd::string accountId;
    /// 请求 ID
    nstd::string requestId;
    /// 请求大模型的内容
    V2NIMAIModelCallContent content;
    /// 上下文内容
    nstd::optional<nstd::vector<V2NIMAIModelCallMessage>> messages;
    /// 提示词变量占位符替换, 如果 V2NIMAIUser 中的 modelConfig.prompt 定义了变量，则必填. 端测不校验
    nstd::optional<nstd::string> promptVariables;
    /// 请求接口模型相关参数配置， 如果参数不为空，则默认覆盖控制相关配置
    nstd::optional<V2NIMAIModelConfigParams> modelConfigParams;
    /// 反垃圾配置, 复用消息体里的部分反垃圾字段
    nstd::optional<V2NIMProxyAICallAntispamConfig> antispamConfig;
};

struct V2NIMMessageAIModelCallParams {
    /// AI 代理人的账号
    nstd::string accountId;
    /// 请求大模型的内容
    V2NIMAIModelCallContent aiModelCallParams;
    /// 上下文内容
    nstd::optional<nstd::vector<V2NIMMessage>> messages;
    /// 提示词变量占位符替换
    nstd::optional<nstd::string> promptVariables;
    /// 请求接口模型相关参数配置， 如果参数不为空，则默认覆盖控制相关配置
    nstd::optional<V2NIMAIModelConfigParams> modelConfigParams;
};

struct V2NIMSendMessageParams {
    /// 消息相关配置
    V2NIMMessageConfig messageConfig;
    /// 路由抄送相关配置
    V2NIMMessageRouteConfig routeConfig;
    /// 推送相关配置
    V2NIMMessagePushConfig pushConfig;
    /// 反垃圾相关配置
    V2NIMMessageAntispamConfig antispamConfig;
    /// 机器人相关配置
    V2NIMMessageRobotConfig robotConfig;
    /// 是否启用本地反垃圾
    bool clientAntispamEnabled{false};
    /// 本地反垃圾命中后替换的文本
    nstd::string clientAntispamReplace;
    /// 请求大模型的相关参数
    nstd::optional<V2NIMMessageAIConfigParams> aiConfig;
};

struct V2NIMMessageRevokeParams {
    /// 附言
    nstd::optional<nstd::string> postscript;
    /// 扩展信息
    nstd::optional<nstd::string> serverExtension;
    /// 推送文案
    nstd::optional<nstd::string> pushContent;
    /// 推送数据
    nstd::optional<nstd::string> pushPayload;
    /// 路由抄送地址
    nstd::optional<nstd::string> env;
};

struct V2NIMMessageRevokeNotification {
    /// 被撤回的消息引用
    V2NIMMessageRefer messageRefer;
    /// 扩展信息
    nstd::optional<nstd::string> serverExtension;
    /// 附言
    nstd::optional<nstd::string> postscript;
    /// 消息撤回者账号
    nstd::string revokeAccountId;
    /// 消息撤回类型
    V2NIMMessageRevokeType revokeType{V2NIM_MESSAGE_REVOKE_TYPE_UNDEFINED};
    /// 第三方回调传入的自定义扩展字段
    nstd::optional<nstd::string> callbackExtension;
};

struct V2NIMMessagePin {
    /// pin 消息引用
    V2NIMMessageRefer messageRefer;
    /// 操作者 ID
    nstd::string operatorId;
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 创建时间
    uint64_t createTime{0};
    /// 更新时间
    uint64_t updateTime{0};
};

struct V2NIMMessagePinNotification {
    /// 消息 PIN 状态
    V2NIMMessagePinState pinState{V2NIM_MESSAGE_PIN_STEATE_NOT_PINNED};
    /// 消息相关的PIN信息
    V2NIMMessagePin pin;
};

struct V2NIMSendCustomNotificationParams {
    /// 通知相关配置
    V2NIMNotificationConfig notificationConfig;
    /// 离线推送配置相关
    V2NIMNotificationPushConfig pushConfig;
    /// 反垃圾相关配置
    V2NIMNotificationAntispamConfig antispamConfig;
    /// 路由抄送相关配置
    V2NIMNotificationRouteConfig routeConfig;
};

struct V2NIMClientAntispamResult {
    /// 客户端反垃圾文本命中后操作类型
    V2NIMClientAntispamOperateType operateType{V2NIM_CLIENT_ANTISPAM_OPERATE_NONE};
    /// 处理后的文本内容
    nstd::string replacedText;
};

struct V2NIMSendMessageResult {
    /// 发送成功后的消息体
    V2NIMMessage message;
    /// 反垃圾返回的结果
    nstd::optional<nstd::string> antispamResult;
    /// 客户端本地反垃圾结果
    nstd::optional<V2NIMClientAntispamResult> clientAntispamResult;
};

struct V2NIMTeamMessageReadReceipt {
    /// 会话 ID
    nstd::string conversationId;
    /// 消息服务器 ID
    nstd::string messageServerId;
    /// 消息客户端 ID
    nstd::string messageClientId;
    /// 群消息已读人数
    uint32_t readCount{0};
    /// 群消息未读人数
    uint32_t unreadCount{0};
    /// 群消息最新已读账号
    nstd::optional<nstd::string> latestReadAccount;
};

struct V2NIMTeamMessageReadReceiptDetail {
    /// 群消息已读回执
    V2NIMTeamMessageReadReceipt readReceipt;
    /// 已读账号列表
    nstd::vector<nstd::string> readAccountList;
    /// 未读账号列表
    nstd::vector<nstd::string> unreadAccountList;
};

struct V2NIMP2PMessageReadReceipt {
    /// 会话 ID
    nstd::string conversationId;
    /// 最后一条已读消息时间, 比该时间早的消息都可以认为已读
    uint64_t timestamp{0};
};

struct V2NIMMessageClientAntispamResult {
    /// 客户端反垃圾文本命中后操作类型
    V2NIMMessageClientAntispamOperatorType operateType{V2NIM_MESSAGE_CLIENT_ANTISPAM_OPERATOR_NONE};
    /// 处理后的文本内容
    nstd::string replaceContent;
};

struct V2NIMMessageListOption {
    /// 根据消息类型查询会话, 为空表示查询所有消息类型
    nstd::vector<V2NIMMessageType> messageTypes;
    /// 会话 ID
    nstd::string conversationId;
    /// 消息查询开始时间, 闭区间
    uint64_t beginTime{0};
    /// 消息查询结束时间, 闭区间
    uint64_t endTime{0};
    /// 查询条数
    uint32_t limit{V2NIM_DEFAULT_MESSAGE_LIST_LIMIT};
    /// 锚点消息, 根据锚点消息查询, 不包含该消息
    nstd::optional<V2NIMMessage> anchorMessage;
    /// 是否反向排序
    bool reverse{false};
    /// 消息查询方向
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    /// 严格模式, 无法确定消息完整性则返回错误
    bool strictMode{false};
};

struct V2NIMClearHistoryMessageOption {
    /// 需要清空消息的对应的会话 ID
    nstd::string conversationId;
    /// 是否同步删除漫游消息, 默认删除, 该字段只 P2P 时有效
    bool deleteRoam{true};
    /// 是否多端同步, 默认不同步
    bool onlineSync{false};
    ///  扩展字段, 多端同步时会同步到其它端
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMMessageQuickCommentPushConfig {
    /// 是否需要推送
    bool needPush{true};
    /// 是否需要角标
    bool needBadge{true};
    /// 推送标题
    nstd::string pushTitle;
    /// 推送内容
    nstd::string pushContent;
    /// 推送自定义字段
    nstd::string pushPayload;
};

struct V2NIMMessageQuickComment {
    /// 消息引用
    V2NIMMessageRefer messageRefer;
    /// 操作者 ID
    nstd::string operatorId;
    /// 评论索引
    uint64_t index{0};
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 创建时间
    nstd::optional<uint64_t> createTime;
};

struct V2NIMMessageQuickCommentNotification {
    /// 快捷评论操作类型
    V2NIMMessageQuickCommentType operationType{V2NIM_MESSAGE_QUICK_COMMENT_TYPE_ADD};
    /// 快捷评论
    V2NIMMessageQuickComment quickComment;
};

struct V2NIMMessageDeletedNotification {
    /// 被删除的消息引用
    V2NIMMessageRefer messageRefer;
    /// 被删除的时间
    uint64_t deleteTime{0};
    /// 被删除时填入的扩展字段
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMClearHistoryNotification {
    /// 会话 ID
    nstd::string conversationId;
    /// 被删除的时间
    uint64_t deleteTime{0};
    /// 被删除时填入的扩展字段
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMCollection {
    /// 收藏信息服务端 ID
    nstd::string collectionId;
    /// 收藏索引
    uint32_t collectionType{0};
    /// 收藏数据
    nstd::string collectionData;
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 创建时间
    uint64_t createTime{0};
    /// 更新时间
    uint64_t updateTime{0};
};

struct V2NIMAddCollectionParams {
    /// 收藏类型
    uint32_t collectionType{0};
    /// 收藏数据
    nstd::string collectionData;
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMCollectionOption {
    /// 查询开始时间区间, 闭区间
    uint64_t beginTime{0};
    /// 查询结束时间区间, 闭区间, 0 表示当前时间
    uint64_t endTime{0};
    /// 查询锚点
    nstd::optional<V2NIMCollection> anchorCollection;
    /// 查询方向
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    /// 每次查询收藏条数
    uint32_t limit{V2NIM_DEFAULT_COLLECTION_LIST_LIMIT};
    /// 收藏类型
    uint32_t collectionType{0};
};

/// @brief 动态 token 获取回调
/// @param accountId 账号
/// @return token
using V2NIMTokenProvider = nstd::function<nstd::optional<nstd::string>(nstd::string accountId)>;

/// @brief 登陆扩展信息获取回调
/// @param accountId 账号
/// @return 登陆扩展信息
using V2NIMLoginExtensionProvider = nstd::function<nstd::optional<nstd::string>(nstd::string accountId)>;

/// @brief 聊天室 token 获取回调
/// @param roomId 聊天室 ID
/// @param account 账号
/// @return token
using V2NIMChatroomTokenProvider = nstd::function<nstd::optional<nstd::string>(nstd::string roomId, nstd::string account)>;

/// @brief 聊天室登陆扩展信息获取回调
/// @param roomId 聊天室 ID
/// @param account 账号
/// @return token
using V2NIMChatroomLoginExtensionProvider = nstd::function<nstd::optional<nstd::string>(nstd::string roomId, nstd::string account)>;

/// @brief 聊天室 link 获取回调
/// @param roomId 聊天室 ID
/// @param account 账号
/// @return link
using V2NIMChatroomLinkProvider = nstd::function<nstd::vector<nstd::string>(nstd::string roomId, nstd::string account)>;

struct V2NIMLoginOption {
    /// 重试次数
    uint32_t retryCount{3};
    /// 登录超时, 单位毫秒
    uint64_t timeout{V2NIM_DEFAULT_LOGIN_TIMEOUT};
    /// 强制登录模式
    bool forceMode{false};
    /// 认证类型
    V2NIMLoginAuthType authType{V2NIM_LOGIN_AUTH_TYPE_DEFAULT};
    /// 动态 token 获取回调
    V2NIMTokenProvider tokenProvider{nullptr};
    /// 登陆扩展信息获取回调
    V2NIMLoginExtensionProvider loginExtensionProvider{nullptr};
    /// 数据同步等级
    V2NIMDataSyncLevel syncLevel{V2NIM_DATA_SYNC_LEVEL_FULL};
};

struct V2NIMLoginClient {
    /// 客户端类型
    V2NIMLoginClientType type{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    /// 操作系统
    nstd::string os;
    /// 登录时间
    uint64_t timestamp{0};
    /// 自定义信息
    nstd::string customTag;
    /// 自定义类型
    uint32_t customClientType{0};
    /// 客户端 ID
    nstd::string clientId;
};

struct V2NIMKickedOfflineDetail {
    /// 原因
    V2NIMKickedOfflineReason reason{V2NIM_KICKED_OFFLINE_REASON_CLIENT_EXCLUSIVE};
    /// 说明
    nstd::string reasonDesc;
    /// 客户端类型
    V2NIMLoginClientType clientType{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    /// 自定义客户端类型
    uint32_t customClientType{0};
};

struct V2NIMDataSyncDetail {
    /// 数据同步类型
    V2NIMDataSyncType type{V2NIM_DATA_SYNC_MAIN};
    /// 数据同步状态
    V2NIMDataSyncState state{V2NIM_DATA_SYNC_STATE_WAITING};
};

struct V2NIMLastMessage {
    /// 最后一条消息状态
    V2NIMLastMessageState lastMessageState{V2NIM_MESSAGE_STATE_DEFAULT};
    /// 最后一条消息引用
    nstd::optional<V2NIMMessageRefer> messageRefer;
    /// 最后一条消息类型
    nstd::optional<V2NIMMessageType> messageType;
    /// 消息子类型
    nstd::optional<uint32_t> subType;
    /// 消息发送状态
    nstd::optional<V2NIMMessageSendingState> sendingState;
    /// 消息文本内容或撤回附言
    nstd::string text;
    /// 消息附件
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    /// 消息撤回者账号
    nstd::optional<nstd::string> revokeAccountId;
    /// 消息撤回类型
    nstd::optional<V2NIMMessageRevokeType> revokeType;
    /// 发送者账号信息
    nstd::optional<nstd::string> senderId;
    /// 如果是正常接收的消息，则显示发送者昵称。如果是被撤回的消息，则显示消息撤回者昵称。显示规则：如果是好友，则返回好友备注，否则如果是群成员，返回群成员昵称，否则返回用户昵称
    nstd::optional<nstd::string> senderName;
    /// 扩展信息
    nstd::optional<nstd::string> serverExtension;
    /// 第三方扩展字段
    nstd::optional<nstd::string> callbackExtension;
};

struct V2NIMConversation {
    /// 会话标识
    nstd::string conversationId;
    /// 会话类型
    V2NIMConversationType type{V2NIM_CONVERSATION_TYPE_UNKNOWN};
    /// 会话名称
    nstd::optional<nstd::string> name;
    /// 会话头像
    nstd::optional<nstd::string> avatar;
    /// 免打扰
    bool mute{false};
    /// 置顶
    bool stickTop{false};
    /// 会话分组 ID 列表
    nstd::vector<nstd::string> groupIds;
    /// 本地扩展信息
    nstd::optional<nstd::string> localExtension;
    /// 服务端扩展信息
    nstd::optional<nstd::string> serverExtension;
    /// 最后一条消息
    nstd::optional<V2NIMLastMessage> lastMessage;
    /// 未读计数
    uint32_t unreadCount{0};
    /// 会话排序时间
    uint64_t sortOrder{0};
    /// 会话创建时间
    uint64_t createTime{0};
    /// 会话更新时间
    uint64_t updateTime{0};
};

struct V2NIMConversationResult {
    /// 下一次拉取的偏移
    uint64_t offset{0};
    /// 数据是否拉取完毕
    bool finished{false};
    /// 会话列表
    nstd::vector<V2NIMConversation> conversationList;
};

struct V2NIMConversationOperationResult {
    /// 会话标识
    nstd::string conversationId;
    /// 错误
    V2NIMError error;
};

struct V2NIMConversationUpdate {
    /// 服务端扩展字段
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMConversationOption {
    /// 查询指定会话类型, empty: 不限制会话类型
    nstd::vector<V2NIMConversationType> conversationTypes;
    /// 查询指定分组的会话, null: 查询所有分组, empty: 查询未分组的会话
    nstd::optional<nstd::vector<nstd::string>> conversationGroupIds;
    /// false: 查询所有会话, true: 查询包含未读的会话
    bool onlyUnread{false};
};

struct V2NIMConversationFilter {
    /// 过滤指定对话类型, empty: 不限制会话类型
    nstd::set<V2NIMConversationType> conversationTypes;
    /// 过滤指定分组的会话, nullopt: 不过滤会话分组
    nstd::string conversationGroupId;
    /// 过滤免打扰会话
    bool ignoreMuted{false};
};

struct V2NIMConversationGroup {
    /// 会话分组 ID
    nstd::string groupId;
    /// 会话分组名称
    nstd::string name;
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 创建时间
    uint64_t createTime{0};
    /// 更新时间
    uint64_t updateTime{0};
};

struct V2NIMConversationGroupResult {
    /// 会话分组信息
    V2NIMConversationGroup group;
    /// 失败的会话列表
    nstd::vector<V2NIMConversationOperationResult> failedList;
};

struct V2NIMMessageSearchParams {
    /// 关键字
    nstd::string keyword;
    /// 查询起始时间
    uint64_t beginTime{0};
    /// 查询结束时间, 0 表示当前时间
    uint64_t endTime{0};
    /// 检索会话数量
    uint32_t conversationLimit{0};
    /// 返回消息数量
    uint32_t messageLimit{V2NIM_DEFAULT_SEARCH_MESSAGE_LIST_LIMIT};
    /// 消息排序规则
    V2NIMSortOrder sortOrder{V2NIM_SORT_ORDER_DESC};
    /// P2P 账号列表
    nstd::vector<nstd::string> p2pAccountIds;
    /// 高级群账号列表
    nstd::vector<nstd::string> teamIds;
    /// 发送账号列表
    nstd::vector<nstd::string> senderAccountIds;
    /// 要检索的消息类型, 为空表示查询所有消息类型
    nstd::vector<V2NIMMessageType> messageTypes;
    /// 要检索的消息子类型, 为空表示查询所有消息子类型
    nstd::vector<uint32_t> messageSubTypes;
};

struct V2NIMVoiceToTextParams {
    /// 本地语音文件路径, 若为空则使用 url
    nstd::string voicePath;
    /// 语音 url, 若为空则根据 voicePath 自动上传
    nstd::string voiceUrl;
    /// 音频类型, aac, wav, mp3, amr等
    nstd::string mimeType;
    /// 采样率
    nstd::string sampleRate;
    /// 语音时长, 单位毫秒
    uint64_t duration{0};
    /// 文件存储场景
    nstd::string sceneName;
};

struct V2NIMTeam {
    /// 群组ID
    nstd::string teamId;
    /// 群组类型
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    /// 群组名称
    nstd::string name;
    /// 群组创建者/拥有者 ID
    nstd::string ownerAccountId;
    /// 群组人数上限
    uint32_t memberLimit{0};
    /// 群组当前人数
    uint32_t memberCount{0};
    /// 群组创建时间
    uint64_t createTime{0};
    /// 群组更新时间
    uint64_t updateTime{0};
    /// 群组介绍
    nstd::optional<nstd::string> intro;
    /// 群组公告
    nstd::optional<nstd::string> announcement;
    /// 群组头像
    nstd::optional<nstd::string> avatar;
    /// 服务端扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 客户自定义扩展, 由openApi设置
    nstd::optional<nstd::string> customerExtension;
    /// 申请入群模式, 入群验证方式
    V2NIMTeamJoinMode joinMode{V2NIM_TEAM_JOIN_MODE_APPLY};
    /// 被邀请人入群模式, 被邀请人的同意方式
    V2NIMTeamAgreeMode agreeMode{V2NIM_TEAM_AGREE_MODE_AUTH};
    /// 群组邀请模式, 谁可以邀请他人入群
    V2NIMTeamInviteMode inviteMode{V2NIM_TEAM_INVITE_MODE_MANAGER};
    /// 群组资料修改模式, 谁可以修改群组资料
    V2NIMTeamUpdateInfoMode updateInfoMode{V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER};
    /// 群组扩展字段修改模式, 谁可以修改群组扩展
    V2NIMTeamUpdateExtensionMode updateExtensionMode{V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER};
    /// 群禁言状态
    V2NIMTeamChatBannedMode chatBannedMode{V2NIM_TEAM_CHAT_BANNED_MODE_NONE};
    /// 是否为自己所在且有效的群, 群存在且我在群组中
    bool isValidTeam{true};
    /// @internal
    uint32_t bits{0};
    /// @internal
    nstd::optional<uint64_t> teamMemberTime;
};

struct V2NIMTeamMember {
    /// 群组ID
    nstd::string teamId;
    /// 群组类型
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    /// 群组成员账号
    nstd::string accountId;
    /// 群组成员类型
    nstd::optional<V2NIMTeamMemberRole> memberRole;
    /// 群组昵称
    nstd::optional<nstd::string> teamNick;
    /// 服务端扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 入群时间
    nstd::optional<uint64_t> joinTime;
    /// 更新时间
    nstd::optional<uint64_t> updateTime;
    /// 入群邀请人
    nstd::optional<nstd::string> invitorAccountId;
    /// 是否在群中
    nstd::optional<bool> inTeam;
    /// 聊天是否被禁言
    nstd::optional<bool> chatBanned;
    /// @internal
    nstd::optional<uint64_t> bits;
};

// @internal
struct V2NIMTeamMemberUpdateParams {
    /// 群组ID
    nstd::string teamId;
    /// 群组类型
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    /// 群组成员账号
    nstd::string accountId;
    /// 群组成员类型
    nstd::optional<V2NIMTeamMemberRole> memberRole;
    /// 群组昵称
    nstd::optional<nstd::string> teamNick;
    /// 内部使用字段
    nstd::optional<uint64_t> bits;
    /// 服务端扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 入群时间
    nstd::optional<uint64_t> joinTime;
    /// 更新时间
    nstd::optional<uint64_t> updateTime;
    /// 入群邀请人
    nstd::optional<nstd::string> invitorAccountId;
    /// 是否在群中
    nstd::optional<bool> inTeam;
    /// 聊天是否被禁言
    nstd::optional<bool> chatBanned;
};

struct V2NIMCreateTeamParams {
    /// 群组名称
    nstd::string name;
    /// 群组类型
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    /// 群组人数上限
    nstd::optional<uint32_t> memberLimit;
    /// 群组介绍
    nstd::optional<nstd::string> intro;
    /// 群组公告
    nstd::optional<nstd::string> announcement;
    /// 群组头像
    nstd::optional<nstd::string> avatar;
    /// 服务端扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 申请入群模式, 入群验证方式
    V2NIMTeamJoinMode joinMode{V2NIM_TEAM_JOIN_MODE_APPLY};
    /// 被邀请人入群模式, 被邀请人的同意方式
    V2NIMTeamAgreeMode agreeMode{V2NIM_TEAM_AGREE_MODE_AUTH};
    /// 群组邀请模式, 谁可以邀请他人入群
    V2NIMTeamInviteMode inviteMode{V2NIM_TEAM_INVITE_MODE_MANAGER};
    /// 群组资料修改模式, 谁可以修改群组资料
    V2NIMTeamUpdateInfoMode updateInfoMode{V2NIM_TEAM_UPDATE_INFO_MODE_MANAGER};
    /// 群组扩展字段修改模式, 谁可以修改群组扩展
    V2NIMTeamUpdateExtensionMode updateExtensionMode{V2NIM_TEAM_UPDATE_EXTENSION_MODE_MANAGER};
    /// 群禁言状态
    V2NIMTeamChatBannedMode chatBannedMode{V2NIM_TEAM_CHAT_BANNED_MODE_NONE};
};

struct V2NIMTeamMemberQueryOption {
    /// 群成员类型
    nstd::optional<V2NIMTeamMemberRoleQueryType> roleQueryType;
    /// 是否只返回聊天禁言成员列表
    bool onlyChatBanned{false};
    /// 消息查询方向
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    /// 分页偏移, 首次传空, 后续拉取采用上一次返回的 nextToken
    nstd::string nextToken;
    /// 分页拉取数量
    uint32_t limit{V2NIM_DEFAULT_TEAM_MEMBER_LIST_LIMIT};
};

struct V2NIMCreateTeamResult {
    /// 被创建的群组信息
    V2NIMTeam team;
    /// 被邀请成员失败列表
    nstd::vector<nstd::string> failedList;
};

struct V2NIMUpdateSelfMemberInfoParams {
    /// 设置的群昵称
    nstd::optional<nstd::string> teamNick;
    /// 设置的群成员扩展字段
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMTeamMemberListResult {
    /// 数据是否拉取完毕
    bool finished{false};
    /// 下一次查询的偏移量
    nstd::string nextToken;
    /// 拉取的成员列表
    nstd::vector<V2NIMTeamMember> memberList;
};

struct V2NIMTeamJoinActionInfo {
    /// 入群操作类型
    V2NIMTeamJoinActionType actionType{V2NIM_TEAM_JOIN_ACTION_TYPE_APPLICATION};
    /// 群组ID
    nstd::string teamId;
    /// 群组类型
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    /// 申请者账号
    nstd::string operatorAccountId;
    /// 申请入群的附言
    nstd::optional<nstd::string> postscript;
    /// 申请时间
    uint64_t timestamp{0};
    /// 操作状态
    V2NIMTeamJoinActionStatus actionStatus{V2NIM_TEAM_JOIN_ACTION_STATUS_INIT};
};

struct V2NIMAntispamConfig {
    /// 易盾业务 ID
    nstd::string antispamBusinessId;
};

struct V2NIMUser {
    /// 账号 ID
    nstd::string accountId;
    /// 用户昵称
    nstd::optional<nstd::string> name;
    /// 用户头像
    nstd::optional<nstd::string> avatar;
    /// 用户签名
    nstd::optional<nstd::string> sign;
    /// 用户邮箱
    nstd::optional<nstd::string> email;
    /// 用户生日
    nstd::optional<nstd::string> birthday;
    /// 用户手机号
    nstd::optional<nstd::string> mobile;
    /// 用户性别
    nstd::optional<uint32_t> gender;
    /// 用户扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 用户资料创建时间
    uint64_t createTime{0};
    /// 用户资料更新时间
    uint64_t updateTime{0};
};

struct V2NIMUserUpdateParams {
    /// 用户昵称
    nstd::optional<nstd::string> name;
    /// 用户头像
    nstd::optional<nstd::string> avatar;
    /// 用户签名
    nstd::optional<nstd::string> sign;
    /// 用户邮箱
    nstd::optional<nstd::string> email;
    /// 用户生日
    nstd::optional<nstd::string> birthday;
    /// 用户手机号
    nstd::optional<nstd::string> mobile;
    /// 用户性别
    nstd::optional<uint32_t> gender;
    /// 用户扩展字段
    nstd::optional<nstd::string> serverExtension;
};

/// @brief 用户搜索选项
struct V2NIMUserSearchOption {
    /// 搜索关键字
    nstd::string keyword;
    /// 是否搜索用户昵称
    bool searchName{true};
    /// 是否搜索用户账号
    bool searchAccountId{false};
    /// 是否搜索手机号
    bool searchMobile{false};
};

struct V2NIMFriend {
    /// 好友账号
    nstd::string accountId;
    /// 好友备注
    nstd::optional<nstd::string> alias;
    /// 好友扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 用户扩展字段
    nstd::optional<nstd::string> customerExtension;
    /// 创建时间
    nstd::optional<uint64_t> createTime;
    /// 更新时间
    nstd::optional<uint64_t> updateTime;
    /// 好友对应的用户信息
    V2NIMUser userProfile;
    /// @internal
    nstd::optional<uint32_t> flag;
    /// @internal
    nstd::optional<uint32_t> beflag;
};

struct V2NIMFriendAddParams {
    /// 添加好友模式
    V2NIMFriendAddMode addMode{V2NIM_FRIEND_MODE_TYPE_ADD};
    /// 添加/申请添加好友的附言
    nstd::optional<nstd::string> postscript;
};

struct V2NIMFriendAddApplication {
    /// 申请者账号
    nstd::string applicantAccountId;
    /// 被申请者账号
    nstd::string recipientAccountId;
    /// 操作者账号
    nstd::string operatorAccountId;
    /// 附言
    nstd::optional<nstd::string> postscript;
    /// 状态
    V2NIMFriendAddApplicationStatus status{V2NIM_FRIEND_ADD_APPLICATION_STATUS_INIT};
    /// 时间
    uint64_t timestamp{0};
    /// 是否已读
    bool read{false};
};

struct V2NIMFriendDeleteParams {
    /// 是否删除备注
    bool deleteAlias{false};
};

struct V2NIMFriendSetParams {
    /// 别名
    nstd::optional<nstd::string> alias;
    /// 扩展字段
    nstd::optional<nstd::string> serverExtension;
};

struct V2NIMFriendSearchOption {
    /// 搜索关键字， 默认搜索好友备注， 可以指定是否同时搜索用户账号
    nstd::string keyword;
    /// 是否搜索用户昵称
    bool searchAlias{true};
    /// 是否搜索用户账号
    bool searchAccountId{false};
};

struct V2NIMTeamJoinActionInfoQueryOption {
    /// 查询类型
    nstd::vector<V2NIMTeamJoinActionType> types;
    /// 分页偏移
    uint64_t offset;
    /// 查询数量
    uint32_t limit{V2NIM_DEFAULT_JOIN_ACTION_QUERY_LIMIT};
    /// 查询状态
    nstd::vector<V2NIMTeamJoinActionStatus> status;
};

struct V2NIMTeamMemberSearchOption {
    /// 搜索关键词，不为空
    nstd::string keyword;
    /// 群组类型
    V2NIMTeamType teamType{V2NIM_TEAM_TYPE_NORMAL};
    /// 群组ID，如果不传则检索所有群，如果需要检索特定的群，则需要同时传入 teamId + teamType
    nstd::optional<nstd::string> teamId;
    // 起始位置，首次传空， 后续传上次返回的 nextToken
    nstd::string nextToken;
    /// 按照 joinTime 排序，默认时间降序排列
    V2NIMSortOrder order{V2NIM_SORT_ORDER_DESC};
    /// 查询成员的个数，默认 10
    uint32_t limit{V2NIM_DEFAULT_SEARCH_MESSAGE_LIST_LIMIT};
};

struct V2NIMTeamJoinActionInfoResult {
    /// 查询返回的列表
    nstd::vector<V2NIMTeamJoinActionInfo> infos;
    /// 下一次的偏移量
    uint64_t offset{0};
    /// 分页结束
    bool finished{false};
};

struct V2NIMFriendAddApplicationQueryOption {
    /// 分页偏移
    uint64_t offset;
    /// 查询数量
    uint32_t limit{V2NIM_DEFAULT_FRIEND_APPLICATION_QUERY_LIMIT};
    /// 查询状态
    nstd::vector<V2NIMFriendAddApplicationStatus> status;
};

struct V2NIMFriendAddApplicationResult {
    /// 查询返回的列表
    nstd::vector<V2NIMFriendAddApplication> infos;
    /// 下一次的偏移量
    uint64_t offset{0};
    /// 分页结束
    bool finished{false};
};

struct V2NIMDndConfig {
    /// 是否显示详情
    bool showDetail{false};
    /// 免打扰是否开启
    bool dndOn{false};
    /// 如果开启免打扰，开始小时数 (Integer)
    uint32_t fromH{0};
    /// 如果开启免打扰，开始分钟数 (Integer)
    uint32_t fromM{0};
    /// 如果开启免打扰，截止小时数 (Integer)
    uint32_t toH{0};
    /// 如果开启免打扰，截止分钟数 (Integer)
    uint32_t toM{0};
};

struct V2NIMChatroomLoginOption {
    /// 认证模式
    V2NIMLoginAuthType authType{V2NIM_LOGIN_AUTH_TYPE_DEFAULT};
    /// token 获取回调
    V2NIMChatroomTokenProvider tokenProvider{nullptr};
    /// 登陆扩展回调
    V2NIMChatroomLoginExtensionProvider loginExtensionProvider{nullptr};
};

struct V2NIMChatroomTagConfig {
    /// 登陆标签
    nstd::vector<nstd::string> tags;
    /// 登录登出通知标签
    nstd::string notifyTargetTags;
};

struct V2NIMLocationInfo {
    /// 空间坐标 X
    nstd::optional<double> x;
    /// 空间坐标 Y
    nstd::optional<double> y;
    /// 空间坐标 Z
    nstd::optional<double> z;
};

struct V2NIMChatroomLocationConfig {
    /// 空间坐标信息
    V2NIMLocationInfo locationInfo;
    /// 订阅的消息的距离
    nstd::optional<double> distance;
};

struct V2NIMChatroomEnterParams {
    /// 账号 ID
    nstd::string accountId;
    /// 静态 token
    nstd::string token;
    /// 进入聊天室后显示的昵称
    nstd::optional<nstd::string> roomNick;
    /// 进入聊天室后显示的头像
    nstd::optional<nstd::string> roomAvatar;
    /// 登录超时, 单位毫秒
    uint64_t timeout{V2NIM_DEFAULT_LOGIN_TIMEOUT};
    /// 聊天室登录相关信息
    V2NIMChatroomLoginOption loginOption;
    /// 匿名模式
    bool anonymousMode{false};
    /// 获取聊天室 link 链接地址
    V2NIMChatroomLinkProvider linkProvider{nullptr};
    /// 用户扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 通知扩展字段
    nstd::optional<nstd::string> notificationExtension;
    /// 进入聊天室标签信息配置
    V2NIMChatroomTagConfig tagConfig;
    /// 进入聊天室空间位置信息配置
    nstd::optional<V2NIMChatroomLocationConfig> locationConfig;
    /// 反垃圾配置信息
    V2NIMAntispamConfig antispamConfig;
};

struct V2NIMChatroomInfo {
    /// 聊天室 ID
    nstd::string roomId;
    /// 聊天室名称
    nstd::string roomName;
    /// 聊天室公告
    nstd::string announcement;
    /// 视频直播拉流地址
    nstd::string liveUrl;
    /// 聊天室是否有效
    bool isValidRoom{true};
    /// 聊天室扩展字段
    nstd::string serverExtension;
    /// 聊天室队列操作权限模式
    V2NIMChatroomQueueLevelMode queueLevelMode{V2NIM_CHATROOM_QUEUE_LEVEL_MODE_ANY};
    /// 聊天室创建者账号 ID
    nstd::string creatorAccountId;
    /// 聊天室当前在线用户数量
    uint32_t onlineUserCount{0};
    /// 聊天室禁言状态
    bool chatBanned{false};
};

struct V2NIMChatroomCdnInfo {
    bool enabled{false};
    std::vector<std::string> cdnUrls;
    uint64_t timestamp;
    uint64_t pollingInterval;  // seconds
    uint32_t decryptType;
    std::string decryptKey;
    uint64_t pollingTimeout;  // milliseconds
};

struct V2NIMChatroomEnterResult {
    /// 聊天室信息
    V2NIMChatroomInfo chatroom;
    /// 用户信息
    V2NIMChatroomMember selfMember;
};

struct V2NIMChatroomKickedInfo {
    /// 被踢原因
    V2NIMChatroomKickedReason kickedReason{V2NIM_CHATROOM_KICKED_REASON_UNKNOWN};
    /// 被踢扩展字段
    nstd::string serverExtension;
};

struct V2NIMUserInfoConfig {
    /// 消息发送者 uinfo 的最后更新时间
    uint64_t userInfoTimestamp{0};
    /// 发送方昵称
    nstd::string senderNick;
    /// 发送方头像
    nstd::string senderAvatar;
    /// 发送方扩展字段
    nstd::string senderExtension;
};

struct V2NIMChatroomMessageConfig {
    /// 是否需要在服务端保存历史消息
    bool historyEnabled{true};
    /// 是否是高优先级消息
    bool highPriority{false};
};

struct V2NIMChatroomMessage {
    /// 客户端消息 ID
    nstd::string messageClientId;
    /// 消息发送方客户端类型
    V2NIMLoginClientType senderClientType{V2NIM_LOGIN_CLIENT_TYPE_UNKNOWN};
    /// 消息时间, 单位毫秒
    uint64_t createTime{0};
    /// 消息发送者账号
    nstd::string senderId;
    /// 聊天室 ID
    nstd::string roomId;
    /// 消息发送者是否是自己
    bool isSelf{false};
    /// 附件上传状态
    V2NIMMessageAttachmentUploadState attachmentUploadState{V2NIM_MESSAGE_ATTACHMENT_UPLOAD_STATE_UNKNOWN};
    /// 消息发送状态
    V2NIMMessageSendingState sendingState{V2NIM_MESSAGE_SENDING_STATE_UNKNOWN};
    /// 消息类型
    V2NIMMessageType messageType{V2NIM_MESSAGE_TYPE_TEXT};
    /// 消息子类型
    uint32_t subType{0};
    /// 消息内容
    nstd::string text;
    /// 消息附属附件
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    /// 服务端扩展
    nstd::optional<nstd::string> serverExtension;
    /// 第三方扩展字段
    nstd::optional<nstd::string> callbackExtension;
    /// 路由抄送相关配置
    V2NIMMessageRouteConfig routeConfig;
    /// 反垃圾相关配置
    V2NIMMessageAntispamConfig antispamConfig;
    /// 消息的目标标签表达式
    nstd::string notifyTargetTags;
    /// 聊天室消息配置
    V2NIMChatroomMessageConfig messageConfig;
    /// 消息发送时的用户信息
    V2NIMUserInfoConfig userInfoConfig;
    /// 消息空间坐标信息配置
    nstd::optional<V2NIMLocationInfo> locationInfo;
};

struct V2NIMSendChatroomMessageParams {
    /// 消息相关配置
    V2NIMChatroomMessageConfig messageConfig;
    /// 路由抄送相关配置
    V2NIMMessageRouteConfig routeConfig;
    /// 反垃圾相关配置
    V2NIMMessageAntispamConfig antispamConfig;
    /// 是否启用本地反垃圾
    bool clientAntispamEnabled{false};
    /// 反垃圾命中后替换的文本
    nstd::string clientAntispamReplace;
    /// 定向消息接收者账号列表, 为空表示不定向, 定向消息不存历史
    nstd::vector<nstd::string> receiverIds;
    /// 消息的目标标签表达式
    nstd::string notifyTargetTags;
    /// 消息空间坐标信息配置
    nstd::optional<V2NIMLocationInfo> locationInfo;
};

struct V2NIMSendChatroomMessageResult {
    /// 发送成功后的消息体
    V2NIMChatroomMessage message;
    /// 云端反垃圾返回的结果
    nstd::string antispamResult;
    /// 客户端本地反垃圾结果
    nstd::optional<V2NIMClientAntispamResult> clientAntispamResult;
};

struct V2NIMChatroomMemberQueryOption {
    /// 需要查询的成员类型
    nstd::vector<V2NIMChatroomMemberRole> memberRoles;
    /// 是否只返回黑名单成员
    bool onlyBlocked{false};
    /// 是否只返回禁言用户
    bool onlyChatBanned{false};
    /// 是否只查询在线成员
    bool onlyOnline{false};
    /// 偏移量
    nstd::string pageToken;
    /// 查询数量
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
};

struct V2NIMChatroomMemberListResult {
    /// 下一次查询的偏移量
    nstd::string pageToken;
    /// 数据是否拉取完毕
    bool finished{false};
    /// 拉取的成员列表
    nstd::vector<V2NIMChatroomMember> memberList;
};

struct V2NIMChatroomMessageListOption {
    /// 消息查询方向
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
    /// 消息类型
    nstd::vector<V2NIMMessageType> messageTypes;
    /// 开始时间
    uint64_t beginTime{0};
    /// 查询数量
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
};

struct V2NIMChatroomMemberRoleUpdateParams {
    /// 设置的成员角色
    V2NIMChatroomMemberRole memberRole{V2NIM_CHATROOM_MEMBER_ROLE_NORMAL};
    /// 设置用户等级
    nstd::optional<uint32_t> memberLevel;
    /// 通知扩展字段
    nstd::optional<nstd::string> notificationExtension;
};

struct V2NIMChatroomSelfMemberUpdateParams {
    /// 聊天室显示的昵称
    nstd::optional<nstd::string> roomNick;
    /// 聊天室显示的头像
    nstd::optional<nstd::string> roomAvatar;
    /// 成员扩展字段
    nstd::optional<nstd::string> serverExtension;
    /// 是否需要通知
    bool notificationEnabled{true};
    /// 本次操作生成的通知中的扩展字段
    nstd::string notificationExtension;
    /// 更新信息持久化
    bool persistence{false};
};

struct V2NIMChatroomTagTempChatBannedParams {
    /// 禁言的 tag
    nstd::string targetTag;
    /// 消息的目标标签表达式
    nstd::string notifyTargetTags;
    /// 禁言时长, 单位秒
    uint64_t duration{0};
    /// 是否需要通知
    bool notificationEnabled{true};
    /// 本次操作生成的通知中的扩展字段
    nstd::string notificationExtension;
};

struct V2NIMChatroomTagsUpdateParams {
    /// 标签
    nstd::optional<nstd::vector<nstd::string>> tags;
    /// 消息的目标标签表达式
    nstd::optional<nstd::string> notifyTargetTags;
    /// 是否需要通知
    bool notificationEnabled{true};
    /// 本次操作生成的通知中的扩展字段
    nstd::string notificationExtension;
};

struct V2NIMChatroomTagMemberOption {
    /// 标签
    nstd::string tag;
    /// 偏移量
    nstd::string pageToken;
    /// 查询条数
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
};

struct V2NIMChatroomTagMessageOption {
    /// 查询的标签
    nstd::vector<nstd::string> tags;
    /// 消息类型
    nstd::vector<V2NIMMessageType> messageTypes;
    /// 查询起始时间
    uint64_t beginTime{0};
    /// 查询结束时间
    uint64_t endTime{0};
    /// 查询条数
    uint32_t limit{V2NIM_DEFAULT_CHATROOM_QUERY_LIMIT};
    /// 查询方向
    V2NIMQueryDirection direction{V2NIM_QUERY_DIRECTION_DESC};
};

struct V2NIMClientAntispamThesaurusItem {
    std::string key;
    V2NIMClientAntispamThesaurusMatchType matchType{V2NIM_CLIENT_ANTISPAM_THESAURUS_MATCH_TYPE_WORD};
    V2NIMClientAntispamOperateType operateType{V2NIM_CLIENT_ANTISPAM_OPERATE_NONE};
    std::string config;
};

struct V2NIMClientAntispamThesaurus {
    std::string name;
    std::string config;
    std::vector<V2NIMClientAntispamThesaurusItem> items;
};

struct V2NIMChatroomQueueOfferParams {
    /// 元素的唯一key
    nstd::string elementKey;
    /// 元素的值
    nstd::string elementValue;
    /// 元素是否瞬态的
    bool transient{false};
    /// 元素属于的账号
    nstd::string elementOwnerAccountId;
};

struct V2NIMUploadFileParams {
    /// 文件地址
    nstd::string filePath;
    /// 场景名
    nstd::string sceneName;
};

struct V2NIMUploadFileTask {
    /// 上传任务 ID
    nstd::string taskId;
    /// 上传任务参数
    V2NIMUploadFileParams uploadParams;
};

struct V2NIMAIModelConfig {
    /// 具体大模型版本模型名
    nstd::string model;
    /// 提示词
    nstd::string prompt;
    /// 提示词对应的变量
    nstd::optional<nstd::vector<nstd::string>> promptKeys;
    /// 模型最大tokens数量
    nstd::optional<uint32_t> maxTokens;
    /// 取值范围(0, 1), 生成时，核采样方法的概率阈值。
    nstd::optional<nstd::string> topP;
    /// 取值范围(0, 2), 用于控制随机性和多样性的程度。
    nstd::optional<nstd::string> temperature;
};

struct V2NIMAIUser : public V2NIMUser {
    /// 模型选择
    V2NIMAIModelType modelType;
    /// 模型相关配置文件
    V2NIMAIModelConfig modelConfig;
};

/// @brief 下载消息附件资源请求参数
struct V2NIMDownloadMessageAttachmentParams {
    /// 消息附件信息
    nstd::shared_ptr<V2NIMMessageAttachment> attachment;
    /// 要下载附件的类型 {@link V2NIMDownloadAttachmentType}
    V2NIMDownloadAttachmentType type{V2NIM_DOWNLOAD_ATTACHMENT_TYPE_SOURCE};
    /// 如果下载的是缩略图或者视频封面，通过该参数指定缩略图大小或视频封面大小
    nstd::optional<V2NIMSize> thumbSize;
    /// 消息客户端 ID，如果指定了该参数将下载完成后的本地附件保存路径更新到消息数据库中，下一次查询时将直接返回对应的路径
    nstd::optional<nstd::string> messageClientId;
    /// 附件保存路径，如未指定 SDK 将下载到登录用户缓存目录，如指定该参数则以指定的路径为准
    nstd::optional<nstd::string> saveAs;
};

struct V2NIMGetMediaResourceInfoResult {
    /// 附件资源完整下载地址
    nstd::string url;
    /// 下载该资源所需的鉴权信息，当列表为空时则代表不需要鉴权，若不为空则需要将该列表添加到请求时的 Header 中
    nstd::map<nstd::string, nstd::string> authHeaders;
};

struct V2NIMSignallingConfig {
    /// 是否需要存离线消息
    nstd::optional<bool> offlineEnabled;
    /// 是否需要计未读
    nstd::optional<bool> unreadEnabled;
    /// 用户 UID
    nstd::optional<int64_t> selfUid;
};

/// @brief 消息推送相关配置
struct V2NIMSignallingPushConfig {
    /// 是否需要推送
    bool pushEnabled{false};
    /// 推送标题
    nstd::optional<nstd::string> pushTitle;
    /// 推送文案
    nstd::optional<nstd::string> pushContent;
    /// 推送数据
    nstd::optional<nstd::string> pushPayload;
};

/// @brief 音视频相关配置
struct V2NIMSignallingRtcConfig {
    /// 云信音视频房间频道名称
    nstd::optional<nstd::string> rtcChannelName;
    /// 音视频房间 token 过期时间
    nstd::optional<uint32_t> rtcTokenTtl;
    /// JSON 格式字符串，音视频 SDK 相关参数，IM 信令仅透传相关参数
    nstd::optional<nstd::string> rtcParams;
};

/// @brief 信令呼叫参数
struct V2NIMSignallingCallParams {
    /// 被呼叫者账号 ID
    nstd::string calleeAccountId;
    /// 请求 ID，可以用 UUID 实现
    nstd::string requestId;
    /// 频道类型
    V2NIMSignallingChannelType channelType{V2NIM_SIGNALLING_CHANNEL_TYPE_UNKNOWN};
    /// 频道名称，建议使用与业务有相关场景的名称，便于页面显示
    nstd::optional<nstd::string> channelName;
    /// 频道相关扩展字段，长度限制 4096，跟频道绑定，JSON 格式
    nstd::optional<nstd::string> channelExtension;
    /// 服务器扩展字段，长度限制 4096，JSON 格式
    nstd::optional<nstd::string> serverExtension;
    /// 信令相关配置
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    /// 推送相关配置
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
    /// 音视频相关参数配置
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};

/// @brief 信令频道信息
struct V2NIMSignallingChannelInfo {
    /// 信令频道 ID，唯一标识了该频道房间，后续主要以该字段作为请求标识
    nstd::string channelId;
    /// 频道类型
    V2NIMSignallingChannelType channelType;
    /// 信令频道名称，如果请求时不传，则该字段为空
    nstd::optional<nstd::string> channelName;
    /// 频道相关扩展字段，长度限制 4096，JSON 格式
    nstd::optional<nstd::string> channelExtension;
    /// 频道房间创建时间
    time_t createTime{0};
    /// 频道房间过期时间
    time_t expireTime{0};
    /// 创建者账号 ID
    nstd::string creatorAccountId;
};

/// @brief 信令房间用户信息
struct V2NIMSignallingMember {
    /// 成员账号 ID
    nstd::string accountId;
    /// 成员 UID
    int64_t uid{0};
    /// 用户加入信令频道房间时间
    time_t joinTime{0};
    /// 用户信令频道房间过期时间
    time_t expireTime{0};
    /// 成员操作的设备 ID
    nstd::string deviceId;
};

/// @brief 信令房间相关信息
struct V2NIMSignallingRoomInfo {
    /// 频道房间相关信息
    V2NIMSignallingChannelInfo channelInfo;
    /// 成员列表信息
    nstd::vector<V2NIMSignallingMember> members;
};

struct V2NIMSignallingRtcInfo {
    /// 进入音视频对应的 token
    nstd::optional<nstd::string> rtcToken;
    /// 音视频房间 token 过期时间
    nstd::optional<uint32_t> rtcTokenTtl;
    /// JSON 格式字符串，音视频SDK相关参数，IM 信令仅透传相关参数
    nstd::optional<nstd::string> rtcParams;
};

/// @brief 呼叫回包
struct V2NIMSignallingCallResult {
    /// 频道房间相关信息
    V2NIMSignallingRoomInfo roomInfo;
    /// 音视频房间相关信息
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
    /// 呼叫状态
    int32_t callStatus{0};
};

/// @brief 呼叫建立请求参数，包括接收方进入频道房间相关信息，以及接受方需要的相关音视频房间信息
struct V2NIMSignallingCallSetupParams {
    /// 信令频道 ID，唯一标识了该频道房间
    nstd::string channelId;
    /// 接受的呼叫者账号 ID
    nstd::string callerAccountId;
    /// 请求 ID，可以用 UUID 实现
    nstd::string requestId;
    /// 服务器扩展字段，长度限制 4096，JSON 格式
    nstd::optional<nstd::string> serverExtension;
    /// 信令相关配置
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    /// 音视频相关参数配置
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};

/// @brief 接受呼叫请求回包
struct V2NIMSignallingCallSetupResult {
    /// 频道房间相关信息
    V2NIMSignallingRoomInfo roomInfo;
    /// 音视频房间相关信息
    nstd::optional<V2NIMSignallingRtcInfo> rtcInfo;
    /// 呼叫状态
    nstd::optional<uint32_t> callStatus;
};

/// @brief 加入信令房间请求参数
struct V2NIMSignallingJoinParams {
    /// 信令频道 ID，唯一标识了该频道房间
    nstd::string channelId;
    /// 服务器扩展字段，长度限制 4096
    nstd::optional<nstd::string> serverExtension;
    /// 信令相关配置
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    /// 音视频相关参数配置
    nstd::optional<V2NIMSignallingRtcConfig> rtcConfig;
};

/// @brief 邀请成员加入信令房间请求参数
struct V2NIMSignallingInviteParams {
    /// 信令频道 ID，唯一标识了该频道房间
    nstd::string channelId;
    /// 被邀请者账号 ID
    nstd::string inviteeAccountId;
    /// 请求 ID，可以用 UUID 实现
    nstd::string requestId;
    /// 服务器扩展字段，长度限制 4096，JSON 格式
    nstd::optional<nstd::string> serverExtension;
    /// 信令相关配置
    nstd::optional<V2NIMSignallingConfig> signallingConfig;
    /// 推送相关配置
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
};

/// @brief 取消之前的邀请成员加入信令房间请求参数
struct V2NIMSignallingCancelInviteParams {
    /// 信令频道 ID，唯一标识了该频道房间
    nstd::string channelId;
    /// 被邀请者账号 ID
    nstd::string inviteeAccountId;
    /// 请求 ID，可以用 UUID 实现
    nstd::string requestId;
    /// 服务器扩展字段，长度限制 4096
    nstd::optional<nstd::string> serverExtension;
    /// 是否存离线，true 表示存离线，false 表示不存离线
    nstd::optional<bool> offlineEnabled;
};

/// @brief 拒绝别人邀请加入信令房间请求参数
struct V2NIMSignallingRejectInviteParams {
    /// 信令频道 ID，唯一标识了该频道房间
    nstd::string channelId;
    /// 邀请者账号 ID
    nstd::string inviterAccountId;
    /// 请求 ID，可以用 UUID 实现
    nstd::string requestId;
    /// 服务器扩展字段，长度限制 4096
    nstd::optional<nstd::string> serverExtension;
    /// 是否存离线，true 表示存离线，false 表示不存离线
    nstd::optional<bool> offlineEnabled;
};

/// @brief 拒绝别人邀请加入信令房间请求参数
struct V2NIMSignallingAcceptInviteParams {
    /// 信令频道 ID，唯一标识了该频道房间
    nstd::string channelId;
    /// 邀请者账号 ID
    nstd::string inviterAccountId;
    /// 请求 ID，可以用 UUID 实现
    nstd::string requestId;
    /// 服务器扩展字段，长度限制 4096
    nstd::optional<nstd::string> serverExtension;
    /// 是否存离线，true 表示存离线，false 表示不存离线
    nstd::optional<bool> offlineEnabled;
};

/// @brief 信令事件
struct V2NIMSignallingEvent {
    /// 信令频道事件类型
    V2NIMSignallingEventType eventType;
    /// 信令频道房间相关信息
    V2NIMSignallingChannelInfo channelInfo;
    /// 操作者 ID
    nstd::string operatorAccountId;
    /// 服务器扩展字段，长度限制 4096
    nstd::optional<nstd::string> serverExtension;
    /// 操作的时间点
    uint64_t time;
    /// 被邀请者账号 ID，以下场景包含该字段
    ///  - 邀请加入信令频道房间
    ///  - 取消邀请加入信令频道房间
    nstd::optional<nstd::string> inviteeAccountId;
    /// 邀请者账号 ID，以下场景包含该字段
    ///  - 对方拒绝邀请，
    ///  - 对方接受邀请
    nstd::optional<nstd::string> inviterAccountId;
    /// 本次请求发起产生的请求 ID, 以下场景包含该字段
    ///  - 邀请加入信令房间
    ///  - 拒绝邀请
    ///  - 接受邀请
    ///  - 取消邀请
    nstd::string requestId;
    /// 推送相关配置，以下场景包含该字段，可能为空，依赖于发起方
    ///  - 邀请加入信令房间
    nstd::optional<V2NIMSignallingPushConfig> pushConfig;
    /// 是否需要计未读
    ///  - true：需要
    ///  - false：不需要
    nstd::optional<bool> unreadEnabled;
    /// 成员信息
    ///  - 加入房间事件包括该信息
    nstd::optional<V2NIMSignallingMember> member;
};

}  // namespace v2
#endif
